const Redis = require('ioredis');
const { Sequelize } = require('sequelize');
const configFn = require('./config/config.default.js');
const appConfig = configFn({ name: 'lingxi-system' });

// 创建Redis连接
const redis = new Redis({
  port: 6379,
  host: '127.0.0.1',
  password: '',
  db: 0
});

// 创建数据库连接
const sequelize = new Sequelize(appConfig.sequelize.database, appConfig.sequelize.username, appConfig.sequelize.password, {
  host: appConfig.sequelize.host,
  port: appConfig.sequelize.port,
  dialect: appConfig.sequelize.dialect,
  timezone: appConfig.sequelize.timezone,
  define: appConfig.sequelize.define,
  logging: false, // 关闭SQL日志
});

// 模拟ctx对象
const mockCtx = {
  logger: {
    info: (...args) => console.log('[INFO]', ...args),
    warn: (...args) => console.log('[WARN]', ...args),
    error: (...args) => console.log('[ERROR]', ...args)
  },
  app: {
    redis: redis
  },
  model: {
    SalesOrderModel: require('./app/model/sales_order_model.js')(sequelize),
    SalesOrderItemModel: require('./app/model/sales_order_item_model.js')(sequelize),
    transaction: () => sequelize.transaction()
  }
};

// 从插件数据中提取订单的函数
function extractOrdersFromPluginData(item) {
  const ctx = mockCtx;
  
  try {
    // 检查数据结构 - 改为检查response.result.data
    if (!item || !item.response || !item.response.result || !item.response.result.data) {
      ctx.logger.warn('[PluginData] 插件数据格式不正确，缺少response.result.data');
      return [];
    }
    
    // 获取响应数据 - 改为从response.result.data获取
    let responseData = item.response.result.data;
    if (typeof responseData === 'string') {
      try {
        responseData = JSON.parse(responseData);
      } catch (parseError) {
        ctx.logger.warn('[PluginData] 插件数据格式不正确，无法解析response.result.data');
        return [];
      }
    }
    
    // 检查是否为订单数据格式 - 修正嵌套结构
    let orderDataArray = [];
    
    // 处理政采云数据结构: response.result.data是一个订单数组
    if (Array.isArray(responseData) && responseData.length > 0) {
      // 直接使用responseData作为订单数组
      orderDataArray = responseData;
    }
    
    if (orderDataArray.length === 0) {
      ctx.logger.warn('[PluginData] 订单数据格式不正确，未找到有效的订单数据数组');
      return [];
    }
    
    // 提取订单数据
    const orders = orderDataArray.map(orderItem => {
      // 获取订单基本信息
      const order = orderItem.order || {};
      
      // 获取订单项
      const items = orderItem.items || [];
      
      return {
        // 订单基本信息
        platformOrderId: order.id,  // 平台订单ID
        customerId: order.purchaserId,  // 客户ID
        orderAmount: parseFloat(order.orderTotalFee) || 0,  // 订单金额
        orderStatus: mapOrderStatus(order.status),  // 订单状态
        orderDate: order.createdAt ? new Date(order.createdAt) : new Date(),  // 订单日期
        platformSource: order.platformSource || 'zcy',  // 平台来源
        invoiceStatus: mapInvoiceStatus(order.invoiceStatus),  // 开票状态
        invoiceDate: order.invoiceDate ? new Date(order.invoiceDate) : null,  // 开票日期
        responsibleSalesman: order.responsibleSalesman || '',  // 负责销售
        isGift: order.isGift === 1,  // 是否含赠品
        collectionStatus: order.collectionStatus || 'pending',  // 催款状态
        collectionCount: parseInt(order.collectionCount) || 0,  // 催款次数
        lastCollectionDate: order.lastCollectionDate ? new Date(order.lastCollectionDate) : null,  // 最后催款日期
        lastCollectionResult: order.lastCollectionResult || '',  // 最后催款结果
        nextFollowupDate: order.nextFollowupDate ? new Date(order.nextFollowupDate) : null,  // 下次跟进日期
        orderNo: order.orderNo || '',  // 订单编号
        
        // 订单项
        items: items.map(item => ({
          productId: item.itemId,  // 产品ID
          productName: item.itemName,  // 产品名称
          specification: extractSpecification(item.attributes),  // 规格
          quantity: parseInt(item.quantity) || 0,  // 数量
          unit: extractUnit(item.extraMap),  // 单位
          unitPrice: parseFloat(item.skuPrice) || 0,  // 单价
          amount: parseFloat(item.fee) || 0,  // 金额（使用fee字段而不是amount字段）
          remark: item.remark || ''  // 备注
        }))
      };
    });
    
    ctx.logger.info(`[PluginData] 成功提取 ${orders.length} 条订单数据`);
    return orders;
  } catch (error) {
    ctx.logger.error('[PluginData] 提取订单数据失败:', error);
    return [];
  }
}

// 映射订单状态
function mapOrderStatus(status) {
  // 政采云订单状态映射
  const statusMap = {
    '1': 'pending',      // 待处理
    '3': 'shipped',      // 已发货
    '4': 'completed',    // 已完成
    '-5': 'cancelled',   // 已取消
    '5': 'completed'     // 已验收
  };
  
  return statusMap[status] || 'pending';
}

// 映射开票状态
function mapInvoiceStatus(status) {
  // 政采云开票状态映射
  const statusMap = {
    'uninvoiced': 'uninvoiced',  // 未开票
    'invoiced': 'invoiced',      // 已开票
    'sent': 'sent'               // 已寄送
  };
  
  return statusMap[status] || 'uninvoiced';
}

// 提取规格信息
function extractSpecification(attributes) {
  if (!attributes || !Array.isArray(attributes)) {
    return '';
  }
  
  return attributes.map(attr => `${attr.key}:${attr.value}`).join('; ');
}

// 提取单位信息
function extractUnit(extraMap) {
  if (!extraMap) {
    return '';
  }
  
  return extraMap.unit || '';
}

// 处理订单数据
async function processOrderData(item) {
  const ctx = mockCtx;
  
  try {
    ctx.logger.info('[PluginData] 开始处理订单数据:', item.url);
    
    // 解析订单数据
    const orders = extractOrdersFromPluginData(item);
    
    if (!orders || orders.length === 0) {
      ctx.logger.warn('[PluginData] 未提取到订单数据');
      return { success: false, error: '未提取到订单数据' };
    }
    
    // 批量保存订单数据
    let savedCount = 0;
    let failedCount = 0;
    
    for (const order of orders) {
      try {
        // 检查是否已存在相同的订单记录
        const existing = await ctx.model.SalesOrderModel.findOne({
          where: {
            platformOrderId: order.platformOrderId
          }
        });
        
        if (existing) {
          ctx.logger.info(`[PluginData] 订单已存在，跳过: ${order.platformOrderId}`);
          continue;
        }
        
        // 开启事务
        const transaction = await ctx.model.transaction();
        
        try {
          // 保存订单主表
          const savedOrder = await ctx.model.SalesOrderModel.create({
            platformOrderId: order.platformOrderId,
            customerId: order.customerId,
            orderAmount: order.orderAmount,
            orderStatus: order.orderStatus,
            orderDate: order.orderDate,
            platformSource: order.platformSource,
            invoiceStatus: order.invoiceStatus,
            invoiceDate: order.invoiceDate,
            responsibleSalesman: order.responsibleSalesman,
            isGift: order.isGift,
            collectionStatus: order.collectionStatus,
            collectionCount: order.collectionCount,
            lastCollectionDate: order.lastCollectionDate,
            lastCollectionResult: order.lastCollectionResult,
            nextFollowupDate: order.nextFollowupDate,
            orderNo: order.orderNo,
            organizationId: 1 // 默认组织ID
          }, { transaction });
          
          // 保存订单详情项
          if (order.items && order.items.length > 0) {
            const orderItems = order.items.map(item => ({
              orderId: savedOrder.id,
              productId: item.productId,
              productName: item.productName,
              specification: item.specification,
              quantity: item.quantity,
              unit: item.unit,
              unitPrice: item.unitPrice,
              amount: item.amount,
              remark: item.remark
            }));
            
            await ctx.model.SalesOrderItemModel.bulkCreate(orderItems, { transaction });
          }
          
          // 提交事务
          await transaction.commit();
          savedCount++;
          ctx.logger.info(`[PluginData] 成功保存订单: ${order.platformOrderId}`);
        } catch (transactionError) {
          // 回滚事务
          await transaction.rollback();
          throw transactionError;
        }
      } catch (saveError) {
        failedCount++;
        ctx.logger.error(`[PluginData] 保存订单失败: ${order.platformOrderId}`, saveError);
      }
    }
    
    ctx.logger.info(`[PluginData] 订单数据处理完成 - 成功保存: ${savedCount} 条, 失败: ${failedCount} 条`);
    
    return {
      success: true,
      orderCount: savedCount,
      failedCount: failedCount
    };
  } catch (error) {
    ctx.logger.error('[PluginData] 处理订单数据失败:', error);
    throw error; // 重新抛出错误，以便上层可以正确处理
  }
}

// 测试完整处理流程
async function testFullProcessing() {
  try {
    // 测试数据库连接
    await sequelize.authenticate();
    console.log('数据库连接成功');
    
    const batchId = 'batch_1763968563435_4r6i70dcf';
    const key = `plugin_data_batch:${batchId}`;
    
    console.log(`检查Redis中的批次数据: ${key}`);
    
    // 获取批次数据
    const data = await redis.get(key);
    
    if (data) {
      console.log('批次数据存在');
      const parsedData = JSON.parse(data);
      console.log('数据类型:', typeof parsedData);
      console.log('数据是否为数组:', Array.isArray(parsedData));
      
      if (Array.isArray(parsedData) && parsedData.length > 0) {
        const firstItem = parsedData[0];
        console.log('第一个数据项的类型:', typeof firstItem);
        
        // 测试提取订单数据
        console.log('\n=== 测试订单数据提取 ===');
        const extractedOrders = extractOrdersFromPluginData(firstItem);
        console.log('提取到的订单数量:', extractedOrders.length);
        
        if (extractedOrders.length > 0) {
          console.log('\n第一个订单的详细信息:');
          console.log('平台订单ID:', extractedOrders[0].platformOrderId);
          console.log('客户ID:', extractedOrders[0].customerId);
          console.log('订单金额:', extractedOrders[0].orderAmount);
          console.log('订单状态:', extractedOrders[0].orderStatus);
          console.log('平台来源:', extractedOrders[0].platformSource);
          console.log('发票状态:', extractedOrders[0].invoiceStatus);
          
          console.log('\n第一个订单的订单项数量:', extractedOrders[0].items.length);
          
          // 测试完整处理流程
          console.log('\n=== 测试完整处理流程 ===');
          const result = await processOrderData(firstItem);
          console.log('处理结果:', JSON.stringify(result, null, 2));
          
          // 检查数据库中的订单
          console.log('\n=== 检查数据库中的订单 ===');
          const orders = await sequelize.query('SELECT * FROM sales_orders ORDER BY created_at DESC LIMIT 5', { type: sequelize.QueryTypes.SELECT });
          console.log('最新订单数量:', orders.length);
          orders.forEach((order, index) => {
            console.log(`订单 ${index + 1}:`);
            console.log(`  平台订单ID: ${order.platform_order_id}`);
            console.log(`  订单金额: ${order.order_amount}`);
            console.log(`  订单状态: ${order.order_status}`);
            console.log('---');
          });
        }
      }
    } else {
      console.log('批次数据不存在');
    }
    
    process.exit(0);
  } catch (error) {
    console.error('测试完整处理流程时出错:', error);
    process.exit(1);
  }
}

testFullProcessing();